A thesis notebook based on TiddlyWiki.

This is an example of a thesis notebook powered by TiddlyWiki 5.0.8-beta.

TiddlyWiki is a great piece of software created by Jeremy Ruston. It allows you, among other things, to take notes, organize ideas, store information, and display all your stuff the way you want. It is an incredibly flexible tool you can adapt to fit almost all your needs.

This TiddlyWiki has been customized to serve as a philosophy notebook centered around authors, books and papers, concepts and theories, and personal notes. I use it along with Zotero, which is a dedicated bibliography software. Both are free, open source projects. TiddlyWiki can be downloaded at http://tiddlywiki.com.

buggyj has created several useful plugins, including a WYSIWYG HTML editor, a configurable calendar and tag lists with draggable ordering.

A collection of customisations and macros from Danielo Rodriguez.

This is my personal tiddlywiki file for testing.

Here I will post the tools and Macros that I develop for this awesome tool. That way, all the help the comunity gave me can came back to the comunity again.

A guide to creating a baby journal with TiddlyWiki.

Keeping a journal about your baby is fun. It allows you to keep track of those events in your baby's life and development that are most important to you, and to tell them in your own words. [...]

There are plenty of online services that can help to keep such a diary, but you need to have an internet connection to access them, and you have to trust them to keep your data safe.

A step by step guide to running TiddlyWiki on a CentOS Virtual Private Server.

In this tutorial we will guide you through the steps of installing and running TiddlyWiki on a CentOS 6 VPS.

We will also install and configure Nginx as a reverse proxy, so you can run TiddlyWiki behind Nginx.

A gamers guide to using TiddlyWiki.

I’ve been using TiddlyWiki for this game mainly to record the monsters’ locations and the items that they drop. This is so that when I need a certain item to upgrade/create weapons, I can quickly look it up; which monsters drop it and which quests have those monsters.

As I play the game, as I encounter new information, I just input them into my Shining Ark TiddlyWiki. It’s like I’m building a wiki from scratch. The reason why I don’t just use online wikis is that 1) it’s too easy to get spoiled and 2) sometimes online wikis provide too much information (who cares about the non-gameplay related descriptions that can be found in the game, etc).

Reaction to TiddlyWiki5 from the translator of the German edition of TiddlyWikiClassic.

There is little software that can still inspire me so even after years, as on the first day. This includes TiddlyWiki, the "pocket-wiki". The latter is because the Wiki completely fits into an HTML file, and this HTML file brings everything - JavaScript program logic, CSS appearance and the entire Wiki content as stored records. So a TiddlyWiki file is then sometimes happy times some megabytes in size, but just has the unbeatable advantage that it works just as fast file created locally in a variety of browsers.

(Translation from German by Google Translate)

A beautifully presented timeline widget using vis.js (http://visjs.org).

Source: https://github.com/emkayonline/tw5visjs

This plug-in allows TW5 to display tiddlers using the vis.js graphical timeline and graph widgets.

This plug-in has been testing on OS X with Safari, Chrome and Firefox, but should work under all operating systems and browser supported by TW5 and vis.js.

Also, the plug-in has been designed to work off-line, enabling it to be used without a wireless connection on an iPad/iPhone using TWEdit

Notes and tips by a developer working on writing TiddlyWiki plugins – including TWExe, a widget for running Windows scripts and executables.

A collection of articles covering integration with Fargo, Font Awesome and Google Calendar, and tips for managing task lists.

I have become a regular user of TiddlyWiki and have become so accustomed to using Font Awesome icons in Fargo that I wanted to incorporate the icons into my wikis as well.

A translation of the tiddlywiki.com documentation from Bram Chen, TiddlyWiki's Chinese translator.

Chris Hunt's detailed developer tutorials for getting started with writing widgets for TiddlyWiki.

These pages document aspects TiddlyWiki5 programming, sharing "lessons learned" to help developers to get started with TiddlyWiki5 customization and extension.

There are currently two articles in this wiki:

• A Simple Widget
• A More Complex Widget

Huge collection of customisations and tweaks from Ton Gerner.

I am a longtime user of TiddlyWiki Classic and still use it daily since you can't do everything in TiddlyWiki 5 (yet) ;)

I started experimenting with TW5 at the end of September 2013 (alpha10). Since I missed a few things in the layout I got used to in TiddlyWiki Classic 1, I started with modifying the layout of TW5. To share my knowledge, I made a few guides about these 'modifications'. The guides started as a non-linear personal web notebook (yeah, the subtitle of TiddlyWiki!). I started experimenting with layout things and used TW5 to document my experiments.

Stephan Hradek's growing catalogue of tips and tutorials. Stephan has also developed several plugins and macros that you can find at http://tiddlystuff.tiddlyspot.com/.

Some things in TiddlyWiki seem like Magic. As my preferred nick is Skeeve, I felt that TW5 Magick is a proper name for this collection of some of the "magic" tricks one can do with TiddlyWiki.

Dave Gifford's growing catalogue of tips and tutorials.

TiddlyWiki 5 is a great tool for note-taking, bookmarking, blogging, organizing to do lists, writing books, and more. But many of the things that can be done in TiddlyWiki 5 are often hidden to the new user, either because the user doesn't know about it or because the user doesn't know how to do it. TW5 mall is a modest catalog of hacks where you can discover new tricks in TiddlyWiki 5 and also find out in layman's terms how to implement them.

Tips and guides for using TiddlyWiki.

I never used Node.js until a couple weeks ago when I wanted to try a TW5 installation on Node and expand my knowledge a bit. I figured someone else may be in the same boat so I wrote it all down

A collection of TiddlyWiki resources from Mario Pietsch, with a focus on cloud deployments. Mario also maintains the German translation of TiddlyWiki.

My name is Mario Pietsch from Austria. I'm living near Salzburg.

This page, will be the portal to my TiddlyWiki, TiddlyWeb related content.

Matabele's stylish and clean system for personal task management.

This is my work in progress version of TW5, incorporating various features and ideas as and when they intrigue me. To grab any feature you may wish to try, drag the listed tiddlers across to the dropzone of an empty TiddlyWiki 5.0.10-beta

An introduction to TiddlyWiki in Japanese.

A study notebook for the Bible.

TiddlyWiki5 wouldn't be possible without the ongoing support of the TiddlyWiki user and developer community. Their attention and feedback has made it possible to gain an understanding of what is wanted from the product, and their passion for it has taught me that it is worth the investment that I am making.

TiddlyWiki5 stands on the shoulders of giants by incorporating code from these fine OpenSource projects:

• The Stanford Javascript Crypto Library
• The Jasmine JavaScript Test Framework
• Normalize.css by Nicolas Gallagher

Here's a macro that provides a Twitter Follow button for a particular username:

\define twitterFollowButton(username)
<iframe allowtransparency="true" frameborder="0" scrolling="no" src="//platform.twitter.com/widgets/follow_button.html?screen_name=$username$"  style="width:300px; height:20px;"></iframe>
\end

The only change from the version published at https://dev.twitter.com/docs/follow-button is that new lines have been removed.

Note that the src URL is given without a protocol (ie "http" or "https"). It's done this way so that it works on sites whether they are hosted on a HTTP or HTTPS domain. If you want the Twitter button to work while using a TiddlyWiki offline on a "file://" URL, then you'll need to manually add the protocol. For example:

<iframe allowtransparency="true" frameborder="0" scrolling="no" src="http://platform.twitter.com/widgets/follow_button.html?screen_name=jermolene"  style="width:300px; height:20px;"></iframe>

Alerts are displayed as yellow boxes overlaying the main TiddlyWiki window. Each one corresponds to a tiddler with the tag $:/tags/Alert. Clicking the delete icon on an alert deletes the corresponding tiddler.

Here's a demo alert.

Alert tiddlers should have the following fields:

Current tiddlers:

Submit new entries to this collection of articles via GitHub, Twitter or by posting in the TiddlyWiki Groups.

If there is a SaverModule available that supports it, TiddlyWiki will automatically trigger a save of the current document on clicking tick or delete when editing a tiddler.

You should see a yellow notification at the top right of the window to confirm that an automatic save has taken place.

Automatic saving can be enabled or disabled through the Saving tab of the control panel. Behind the scenes, it is controlled through the configuration tiddler $:/config/AutoSave, which must have the value yes to enable automatic saving.

There are two ways to produce HTML block quotes in TiddlyWiki5, one for content spread across multiple lines, and one for single line content.

Multi-line Block Quotes

The syntax for multi-line block quotes is:

Citation

A citation can be added to the quote like this:

CSS Classes

CSS classes can be added to a block quote:

Single-line Block Quotes

The single-line syntax for block quotes is actually an extension of the syntax for Lists in WikiText. For example:

You can also nest quotes like this:

> A top quote
>> A subquote
> Another top quote

Which renders as:

A top quote

A subquote

Another top quote

You can also mix block quotes with other list items. For example:

Introduction

At its heart, TiddlyWiki5 is a relatively small boot kernel that runs either under Node.js or in the browser with all other functionality added via dynamically loaded modules.

The kernel boots just enough of the TiddlyWiki environment to allow it to load and execute module tiddlers. The module system is compatible with CommonJS and Node.js.

There are many different types of module: parsers, deserializers, widgets etc. It goes much further than you might expect. For example, individual tiddler fields are modules, too: there's a module that knows how to handle the tags field, and another that knows how to handle the special behaviour of the modified and created fields. Some plugin modules have further sub-plugins: the wikitext parser, for instance, accepts parsing rules as individual plugin modules.

Plugins

In TiddlyWiki5, Plugins are bundles of tiddlers that are distributed and managed as one; Modules are JavaScript tiddlers with a module type identifying when and how they should be executed.

The tiddler $:/boot/boot.js is a barebones TiddlyWiki kernel that is just sufficient to load the core plugin modules and trigger a startup module to load up the rest of the application.

The boot kernel includes:

• Several short shared utility functions
• A handful of methods implementing the module mechanism
• The $tw.Tiddler class (and field definition plugins)
• The $tw.Wiki class (and tiddler deserialization methods)
• Code for the browser to load tiddlers from the HTML DOM
• Code for the server to load tiddlers from the file system

Each module is an ordinary CommonJS module, using the require() function to access other modules and the exports global to return JavaScript values. The boot kernel smooths over the differences between Node.js and the browser, allowing the same plugin modules to execute in both environments.

In the browser, core/boot.js is packed into a template HTML file that contains the following elements in order:

• Ordinary and system tiddlers, packed as HTML <DIV> elements
• core/bootprefix.js, containing a few lines to set up the plugin environment
• Optional JavaScript modules, packed as HTML <SCRIPT> blocks
• core/boot.js, containing the boot kernel

On the server, core/boot.js is executed directly. It uses the Node.js local file API to load plugins directly from the file system in the core/modules directory. The code loading is performed synchronously for brevity (and because the system is in any case inherently blocked until plugins are loaded).

The boot process sets up the $tw global variable that is used to store all the state data of the system.

At the end of the boot process the StartupMechanism schedules the execution of startup modules to bring up the rest of TiddlyWiki.

Introduction

The browse widget displays an HTML file browser button that allows the user to choose one or more files to import. It sends a WidgetMessage: tw-import-tiddlers carrying a JSON representation of the tiddlers imported from the files up through its parents. This message usually trapped by the NavigatorWidget which adds the tiddlers to the store and updates the story to display them.

Content and Attributes

The browse widget has no attributes, and ignores any contained content.

BT (née British Telecom) is the UK's largest telecommunications company. In 2007, Osmosoft was acquired by BT. JeremyRuston subsequently left BT in 2011.

Build the specified build targets for the current wiki. If no build targets are specified then all available targets will be built.

--build <target> [<target> ...]

Build targets are defined in the tiddlywiki.info file of a wiki folder.

See TiddlyWikiFolders for details of defining build targets.

TiddlyWiki5 can be used to build older 2.x.x versions of TiddlyWikiClassic from their constituent components. Doing so involves these features:

• The tiddlywiki/classictools plugin, containing a deserializer module which allows tiddlers to be loaded from TiddlyWiki 2.x.x .recipe files
• The stripcomments format for the ViewWidget, which strips single line JavaScript comments starting //#
• The stripTitlePrefix='yes' attribute of the FieldsWidget, which removes prefixes wrapped in curly braces from the title attribute
  • For example, {tiddler}HelloThere would be transformed to HelloThere

Usage

TiddlyWikiClassic is built from the command line by running TiddlyWiki on Node.js. A typical usage would be:

node ../../tiddlywiki.js \
	--verbose \
	--load <path_to_recipe_file> \
	--rendertiddler $:/core/templates/tiddlywiki2.template.html <path_to_write_index_file> text/plain \
	|| exit 1

Introduction

The button widget displays an HTML <button> element that can perform a combination of optional actions when clicked:

• Navigate to a specified tiddler
• Dispatch a user defined widget message
• Trigger a user defined popup
• Assign new text to a specified tiddler

Content and Attributes

The content of the <$button> widget is displayed within the button.

CamelCase is formed by taking a phrase, capitalising each initial letter and smashing them together to form a portmanteau word. Most wikis use CamelCase to signal phrases that should be automatically linked.

The changecount macro returns a counter maintained by the TiddlyWiki core that tracks the number of modifications made to each tiddler. The changecount macro always applies to the tiddler named in the currentTiddler variable.

For example:

<<changecount>>

Displays as:

0

Note how the changecount increases every time this tiddler is modified.

Introduction

This release resolves a number of inconsistencies with the way that filters are handled. The changes mean that existing filters may need to be updated - particularly those that must deal with missing or shadow tiddlers.

Changes to is and addition of all

Most filter operators act by choosing some or all of their source titles to pass through or re-order. Those that add new entries that are not drawn from the source list are referred to as selectors. Prior to 5.0.9-beta, a few filter operators were inconsistent in whether they filtered from the source list or selected new entries into it.

The specific changes are:

• The is operator now always strictly filters from the currently selected list of tiddlers
• The new all operator acts as a selector by replacing the current list with a combination of tiddlers from specific sources:
  • current for the current tiddler
  • missing for all missing tiddlers
  • orphans for all orphan tiddlers
  • shadows for all shadow tiddlers
  • tiddlers for all non-shadow tiddlers (including both system and non-system tiddlers)

The sources for the all operator can be combined with the + character. For example, [all[shadows+tiddlers]] returns all shadow tiddlers and all ordinary tiddlers.

Previously, it was common to have [is[shadow]] at the start of a filter string to select all the shadow tiddlers. In 5.0.9 and above, this will not return all the shadow tiddlers, but instead just those ordinary tiddlers that are also shadow tiddlers (by virtue of having overridden one). The resolution is to use the new all operator. For example, consider this filter from 5.0.8:

[is[shadow]!has[draft.of]tag[$:/tags/AdvancedSearch]] [!is[shadow]!has[draft.of]tag[$:/tags/AdvancedSearch]] +[tag[$:/tags/AdvancedSearch]]

In 5.0.9, that filter has been changed to:

[all[shadows+tiddlers]tag[$:/tags/AdvancedSearch]!has[draft.of]]

Note how the all operator allows operations to be performed on tiddlers from combinations of sources.

Changes to [is[current]]

One result of the changes is that [is[current]] now strictly filters from the source tiddlers; so, if the current tiddler is a missing tiddler not in the source list, then [is[current]] will return an empty list.

The solution is generally to use [all[current]] instead. It doesn't read as well, but has the required behaviour of returning just the current tiddler, regardless of whether it is in the source tiddlers.

Changes to title and field

There are minor changes to the way that the title and field operators work.

The title operator is a selector: it returns the specified title regardless of whether it is in the current source. title is used as the default operator if none is specified

The field operator is a filter: it only returns a subset of the source tiddlers. field is used as the default operator if the supplied operator is not defined (the supplied operator is passed as the suffix to the field operator, so [description[Missing]] is equivalent to [field:description[Missing]]).

Introduction

The checkbox widget displays an HTML <input type="checkbox"> element that is dynamically bound to the presence or absence of a specified tag on a specified tiddler.

Content and Attributes

The content of the <$checkbox> widget is displayed within an HTML <label> element immediately after the checkbox itself. This means that clicking on the content will toggle the checkbox.

Clear the password for subsequent crypto operations

--clearpassword

You can use triple backticks ``` to mark code blocks:

```
This will be monospaced
```

The three backticks need to be at the start of the line and immediately followed by a newline, otherwise they won't be interpreted correctly.

Renders as:

This will be monospaced

Note that some keyboard layouts treat the backtick as a dead key, making it hard to type. The trick is to type three backticks followed by a space. Alternatively, type all six backticks in one go, then a space, and then move the cursor back three characters to type or paste the content.

Colour palettes bind logical colour names (such as page-background) to actual CSS colours (such as #fe0).

Entire colour palettes are stored in a single data tiddler.

The title of the tiddler containing the current colour palette is identified by the tiddler $:/palette.

To retrieve a named colour from the current palette you can use the colour macro:

<<colour page-background>>

The colour macro is defined like this:

\define colour(name)
<$transclude tiddler={{$:/palette}} index="$name$"/>
\end

By convention, each theme provides a default colour palette in the tiddler $:/config/DefaultPalette tiddler. Thus, setting the tiddler $:/theme to the string $:/config/DefaultPalette will revert to the palette packaged with the current theme (as long as it hasn't been redefined, since it is a shadow tiddler).

Palette tiddlers should have the following fields:

The text of a palette tiddler consists of name value pairs like this:

foreground: #000
background: #fff

When run under Node.js, TiddlyWiki supports a command line interface with these built-in commands.

TiddlyWiki is made much more useful by its vibrant community of users and OpenSource developers.

Community Forums

The TiddlyWiki discussion groups are mailing lists for talking about TiddlyWiki: requests for help, announcements of new releases and plugins, debating new features, or just sharing experiences.

• The main TiddlyWiki group: http://groups.google.com/group/TiddlyWiki
• The TiddlyWikiDev group for developers: http://groups.google.com/group/TiddlyWikiDev

  Note that you do not need a Google Account to join the discussion groups. Subscribe by sending an email to mailto:tiddlywiki+subscribe@googlegroups.com or mailto:tiddlywikidev+subscribe@googlegroups.com.

• Follow @TiddlyWiki on Twitter for the latest news
• Get involved in the development on GitHub
• Watch recordings of our regular TiddlyWiki Hangouts

New releases of TiddlyWiki, TiddlyDesktop and TiddlyFox are announced via the discussion groups and Twitter.

Local TiddlyWiki Interest Groups

Local meetings of TiddlyWiki enthusiasts around the world:

• OXTWIG, the Oxford TiddlyWiki Interest Group meets monthly in Oxford, UK to share experiences of using TiddlyWiki

If you are a TiddlyWiki enthusiast please consider starting a local TWIG in your area, it's a great way to spread the word about using TiddlyWiki

Links

This is a sample task for the TaskManagementExample

These are the concepts underlying TiddlyWiki. Understanding how these ideas fit together is the key to getting the most from TiddlyWiki.

Used in Internet protocols to indicate the type that should be used to interpret the content of a web resource.

Under TiddlyWiki5, the type field is gives the content type to apply to the main text field.

TiddlyWiki5 welcomes contributions to its code and documentation via GitHub. Please take a moment to read these notes to help make the process as smooth as possible.

Coding Style

Code contributions should follow the TiddlyWiki Coding Style Guidelines.

GitHub Issues

See ReportingBugs for information about how TiddlyWiki handles bug reports.

Contributor License Agreement

Like other OpenSource projects, TiddlyWiki5 needs a signed contributor license agreement from individual contributors. This is a legal agreement that allows contributors to assert that they own the copyright of their contribution, and that they agree to license it to the UnaMesa Association (the legal entity that owns TiddlyWiki on behalf of the community).

• For individuals use: licenses/CLA-individual
• For entities use: licenses/CLA-entity

This is a first pass at a CLA for TiddlyWiki. Please let us know if we missed something important. If we do have to make essential changes to the CLA, there is a possibility that all contributors will need to sign it again

How to sign the CLA

Create a GitHub pull request to add your name to cla-individual.md or cla-entity.md, with the date in the format (YYYY/MM/DD).

eg: Jeremy Ruston, @Jermolene, 2011/11/22

Thank you!

Attribution

The CLA documents used for this project were created using Harmony Project Templates. "HA-CLA-I-LIST Version 1.0" for "CLA-individual" and "HA-CLA-E-LIST Version 1.0" for "CLA-entity"

Contributing to TiddlyWiki5

TiddlyWiki5 welcomes contributions to its code and documentation via GitHub. Please take a moment to read these notes to help make the process as smooth as possible.

Coding Style

Code contributions should follow the TiddlyWiki Coding Style Guidelines.

GitHub Issues

See ReportingBugs for information about how TiddlyWiki handles bug reports.

Contributor License Agreement

Like other OpenSource projects, TiddlyWiki5 needs a signed contributor license agreement from individual contributors. This is a legal agreement that allows contributors to assert that they own the copyright of their contribution, and that they agree to license it to the UnaMesa Association (the legal entity that owns TiddlyWiki on behalf of the community).

• For individuals use: licenses/CLA-individual
• For entities use: licenses/CLA-entity

This is a first pass at a CLA for TiddlyWiki. Please let us know if we missed something important. If we do have to make essential changes to the CLA, there is a possibility that all contributors will need to sign it again

How to sign the CLA

Create a GitHub pull request to add your name to cla-individual.md or cla-entity.md, with the date in the format (YYYY/MM/DD).

eg: Jeremy Ruston, @Jermolene, 2011/11/22

Thank you!

Attribution

The CLA documents used for this project were created using Harmony Project Templates. "HA-CLA-I-LIST Version 1.0" for "CLA-individual" and "HA-CLA-E-LIST Version 1.0" for "CLA-entity"

This file was automatically generated by TiddlyWiki5

Introduction

The count widget displays the number of matches to a specified filter expression.

Content and Attributes

The content of the <$count> widget is ignored.

This example shows how to create a sub-story within a tiddler that is independent of the main story.

Here's the code:

<$navigator story="MySubStoryList" history="MySubHistoryList">

Click this link to get started: HelloThere

<$list filter="[list[MySubStoryList]]" history="MySubHistoryList">
<div>

! <$button message="tw-close-tiddler" class="btn-invisible">{{$:/core/images/close-button}}</$button> <$view field="title"/>

<$transclude/>
</div>
</$list>

</$navigator>

Note how you can open the HelloThere tiddler in the substory by clicking on the link below. Links within the substory open within the substory, and not in the main story.

Click this link to get started: HelloThere

The CurrentTiddler is the current tiddler during WikiText processing. A context tiddler is set by the TiddlerWidget. It allows you to write references like <$view field="title" format="link"/> in TemplateTiddlers without explicitly specifying the tiddler that it applies to.

You can create an n-dash with a double hyphen -- and an m-dash with a triple hyphen ---. For example – this is an example — and so is this

Data tiddlers provide a way to access blocks of JSON data within the text field of a tiddler.

The implementation of data tiddlers is preliminary, with some intentional limitations.

Data tiddler format

A native data tiddler must have:

• The ContentType field type set to application/json
• Valid JSON data in the text field

For example, the history list tiddler is a data tiddler.

Other tiddler types with alternative formats can also be parsed to yield a block of data that behaves like a data tiddler.

Tiddler dictionary format

The tiddler dictionary format is an alternative syntax for data tiddlers:

• The ContentType field type is set to application/x-tiddler-dictionary
• The text field consists of one or more lines of the form <name>:<value>

For example, the metrics of the Vanilla theme are a tiddler dictionary.

Accessing data within data tiddlers

Currently, it is only possible to access the top level properties of the data using TextReference syntax.

For example, given a application/json tiddler containing:

{"a":"one","b":"two","c":"three"}

Or the equivalent tiddler dictionary of type application/x-tiddler-dictionary:

a:one
b:two
c:three

With either of those definitions {{TiddlerTitle##b}} would have the value two.

The ViewWidget accepts a template attribute that allows the format of date values to be specified. The format string is processed with the following substitutions:

Note that other text is passed through unchanged, allowing commas, colons or other separators to be used.

Examples

These are definitions of technical words and phrases used in this documentation. (As distinct from the concepts that make up TiddlyWiki itself).

HTML definition lists are created with this syntax:

These are sample tiddlers provided as part of TiddlyWiki's documentation.

See DeveloperDocs.

The most practical way to develop plugins is to use Node.js with the tiddlywiki5 repository to build your plugins, and to use GitHub to manage you files.

Step by step

1. Setup your development environment

First read http://tiddlywiki.com/static/PluginMechanism.html.

Install Git from http://git-scm.com/downloads

Install Node.js from http://nodejs.org/

2. Create a new blank repository on GitHub

Hint: GitHub repositories cannot be grouped together into directories, so it is only possible to group by using a naming scheme, e.g. use 'TW5-' as a name prefix with tiddlywiki5 projects to group them together.

Go to https://github.com/ and create new a repository 'pluginname' - choose to add a readme file.

3. Setup a working environment

Choose a location in your file system (eg TW5) for you plugin project; issue commands to:

–create the directory–

mkdir TW5

–make a local read-only copy of the tiddlywiki5 repository–

git clone https://github.com/Jermolene/TiddlyWiki5.git TW5

–make a directory for your plugin–

cd TW5
cd plugins
mkdir yourname
cd yourname
mkdir pluginname

–make a local copy of you plugin repository–

git clone https://github.com/yourgithub/pluginname.git pluginname

–go to your files–

cd pluginname

Create the file plugin.info with content:

{
	"title": "$:/plugins/yourgithub/pluginname",
	"description": "summary of the plugin's purpose",
	"author": "yourname",
	"version": "0.0.1",
	"core-version": ">=5.0.8",
	"source": "https://github.com/yourgithub/pluginname",
	"plugin-type": "plugin"
}

4. Create your plugin's files

For example files see the plugins in the tiddlywiki5 repository i.e. those located at plugins/tiddlywiki/ - Note in particular that files need to contain information that is used to tell tiddlywiki the name of the tiddler that is to be used in the tiddlywiki in place of the name of the file within the file system.

5. Build your files into a tiddlywiki

Modify editions/tw5.com/tiddlywiki.info to include a reference to your plugin directory, i.e. find "plugins": [ and add "yourname/pluginname".

From the TW5 directory issue command

./qbld.sh

the resultant file (index.html) will be placed in the build directory, the default build directory is ../jermolene.github.com relative to TW5/

6. Save your work on GitHub

From plugins/yourname/pluginname/ issue commands to:

–add all files–

git add -A

–commit to your local repository—

git commit -am "something meaningful about this check in"

–copy local changes to github–

git push

This is the main documentation hub for TiddlyWiki. See also TiddlyWiki for Developers.

Concepts

These are the concepts underlying TiddlyWiki. Understanding how these ideas fit together is the key to getting the most from TiddlyWiki.

• ColourPalettes
• CurrentTiddler
• DataTiddlers
• ExternalImages
• Macros
• ModuleType
• Modules
• PermaLinks
• Plugins
• ShadowTiddlers
• SystemTags
• SystemTiddlers
• TemplateTiddlers
• TextReference
• TiddlerFields
• TiddlerFilters
• TiddlerLinks
• TiddlerTags
• Tiddlers
• TiddlyWiki
• TiddlyWiki5
• WidgetMessages
• Wiki
• WikiText
• ContentType
• LazyLoading
• FilterOperators

Wiki Text Rules

• Block Quotes in WikiText
• Code Blocks in WikiText
• Dashes in WikiText
• Definitions in WikiText
• Formatting in WikiText
• HTML in WikiText
• Hard Linebreaks in WikiText
• Headings in WikiText
• Horizontal Rules in WikiText
• Images in WikiText
• Linking in WikiText
• Lists in WikiText
• Macros in WikiText
• Paragraphs in WikiText
• Styles and Classes in WikiText
• Tables in WikiText
• Transclusion in WikiText
• Typed Blocks in WikiText
• Widgets in WikiText

Widgets

Widgets add dynamic functionality to WikiText.

• BrowseWidget
• ButtonWidget
• CheckboxWidget
• CountWidget
• DropzoneWidget
• EditBitmapWidget
• EditTextWidget
• EditWidget
• EncryptWidget
• FieldManglerWidget
• FieldsWidget
• GridWidget
• ImageWidget
• ImportVariablesWidget
• KeyboardWidget
• LinkCatcherWidget
• LinkWidget
• ListWidget
• MacroCallWidget
• NavigatorWidget
• PasswordWidget
• RadioWidget
• RevealWidget
• ScrollableWidget
• SelectWidget
• SetVariableWidget
• SetWidget
• TextWidget
• TiddlerWidget
• TranscludeWidget
• ViewWidget

Commands

When run under Node.js, TiddlyWiki supports a command line interface with these built-in commands.

• BuildCommand
• ClearPasswordCommand
• HelpCommand
• InitCommand
• LoadCommand
• OutputCommand
• PasswordCommand
• RenderTiddlerCommand
• RenderTiddlersCommand
• SaveTiddlerCommand
• SaveTiddlersCommand
• ServerCommand
• SetFieldCommand
• VerboseCommand
• VersionCommand

How to use TiddlyWiki5

• Developing plugins using Node.js and GitHub
• Upgrading
• Building TiddlyWikiClassic
• Installing TiddlyWiki on Node.js
• Scripts for TiddlyWiki on Node.js
• Upgrading TiddlyWiki on Node.js
• Using TiddlyWiki on Node.js
• Working with the TiddlyWiki5 repository
• TiddlyWiki in the Sky for TiddlyWeb
• Creating SubStories
• Generating Static Sites with TiddlyWiki
• How to create a translation for TiddlyWiki
• How to create plugins in the browser
• How to build a TiddlyWiki5 from individual tiddlers
• Making curved text with SVG
• Notes for upgrading to 5.0.11-beta
• Notes for upgrading to 5.0.8-beta
• Setting a favicon
• Sharing a TiddlyWiki on Dropbox
• Using Stylesheets
• Using TiddlyWiki for GitHub Pages project documentation
• Using a custom path prefix with the client-server edition
• Video Tutorials
• Windows HTA Hack
• Saving on Android
• Saving on InternetExplorer
• Saving on TiddlySpot
• Saving on a PHP Server
• Saving on iPad/iPhone
• Saving with Encryption
• Saving with TiddlyFox on Android
• Saving with TiddlyFox
• Saving with TiddlyIE
• Saving with the HTML5 fallback saver
• Using TiddlyWiki on TiddlyDesktop
• Adding a Twitter Follow button
• The First Rule of Using TiddlyWiki

Tips

Hints and tips to help you get the most from TiddlyWiki.

• ReportingBugs
• Adding a Twitter Follow button
• Editing Tiddlers with Emacs
• GoogleChromeTips
• KeyboardShortcuts
• Preserving open tiddlers at startup
• The First Rule of Using TiddlyWiki
• TitlesPolicy

Miscellaneous

• ReportingBugs
• JeremyRuston (aka Jermolene)
• FederatialLimited
• Acknowledgements

Download single file editions of version 5.0.13-beta of TiddlyWiki:

For more advanced configurations, you can run TiddlyWiki on Node.js.

Tiddlers that have a draft.of field are treated as pending drafts of the tiddler specified in the field. Draft tiddlers should also have a draft.title field that specifies the title that will be given to the tiddler when it is saved.

Several features work in concert to give the desired behaviour for draft tiddlers:

• The ListWidget can optionally render draft tiddlers through a different template
• The NavigatorWidget incorporates handlers for the following events:
  • tw-new-tiddler for creating a new tiddler in draft mode
  • tw-edit-tiddler for moving a tiddler into edit mode
  • tw-cancel-tiddler for cancelling a tiddler out of edit mode
  • tw-save-tiddler for saving a draft tiddler
• Draft tiddlers are automatically excluded from search operations

Introduction

The dropzone widget creates an area into which the user can drag files and other objects. It also supports pasting via the clipboard, although browser support is currently limited.

It sends a WidgetMessage: tw-import-tiddlers carrying a JSON representation of the tiddlers to be imported up through its parents. This message usually trapped by the NavigatorWidget which adds the tiddlers to the store and updates the story to display them.

Content and Attributes

The dropzone widget has no attributes, and displays any contained content within the dropzone.

Display

The dropzone widget creates an HTML <div class="tw-dropzone"> to contain its content. During a drag operation the class tw-dragover is added. CSS is used to provide user feedback.

Data types supported

The following data transfer types are supported:

• text/vnd.tiddler - a list of tiddlers in JSON format (this format is generated by the LinkWidget)
• text/plain - plain text
• text/uri-list - a list of URIs as a single tiddler

Introduction

The edit bitmap widget provides a user interface in the browser for editing bitmap tiddlers. It is currently a primitive proof-of-concept, supporting resizing and painting with a single color and line width.

Content and Attributes

The content of the <$edit-bitmap> widget is ignored.

Configuration

The edit bitmap widget can be configured with these system tiddlers:

• $:/config/BitmapEditor/LineWidth determines the line width:
• $:/config/BitmapEditor/Colour determines the line width:

Michael Fogleman has written an Emacs major mode called tid-mode, which is for editing TiddlyWiki .tid files. It is derived from text-mode, uses the useful minor modes org-struct and subword, and updates the modified times when you save a .tid file.

He also wrote two helper functions for using TiddlyWiki in Emacs. The first opens a tiddlers directory in Dired; the second opens TiddlyWiki in the browser.

(defun open-wiki ()
  "Opens a TiddlyWiki directory in Dired."
  (interactive)
  (dired "~/Dropbox/wiki/tiddlers/"))

(defun browse-wiki ()
  "Opens TiddlyWiki in the browser."
  (interactive)
  (browse-url "127.0.0.1:8080/"))

This latter function may require specifying a browser:

(setq browse-url-browser-function 'browse-url-generic
      browse-url-generic-program "chromium")

You can bind either of these functions with the global-set-key function:

(global-set-key (kbd "C-c w") 'open-wiki)

At the moment, these are not integrated into tid-mode.

Introduction

The edit text widget provides a user interface in the browser for editing text tiddler fields. The editing element is dynamically bound to the underlying tiddler value: changes to the tiddler are instantly reflected, and any edits are instantly propogated.

By default, the edit text widget generates a <textarea> as the HTML editing element when the text field is edited, and a <input type="text"> element otherwise. This behaviour can be overridden with the tag and type attributes.

Content and Attributes

The content of the <$edit-text> widget is ignored.

Introduction

The edit widget provides a general purpose interface for editing a tiddler. It dynamically chooses the appropriate widget depending on the type of the tiddler (currently either the EditTextWidget or the EditBitmapWidget).

Content and Attributes

The content of the <$edit> widget is ignored.

TiddlyWiki5 allows the entire content of a TiddlyWiki HTML file to be encrypted with the Stanford JavaScript Crypto Library. Opening an encrypted TiddlyWiki in the browser prompts for a password before decrypting and displaying the content.

For instructions on how to use TiddlyWiki5's encryption features, see Saving with Encryption.

The EncryptionMechanism is implemented with the following elements:

• A PasswordVault within the BootMechanism that holds the current encryption password
• The ability of the BootMechanism to read a block of encrypted tiddlers from the TiddlyWiki file, to prompt the user for a password, and to decrypt the tiddlers
• Handlers for the messages WidgetMessage: tw-set-password and WidgetMessage: tw-clear-password that handle the user interface for password changes
• The EncryptWidget within the main file template that encrypts a filtered list of tiddlers with the currently held password
• The $:/isEncrypted tiddler that contains "yes" or "no" according to whether there is a password in the password vault
  • The availability of this tiddler allows the RevealWidget to be used to selectively display user interface elements according to whether encryption is in force
• The $:/snippets/encryptionstatus snippet displays the current encryption status

Introduction

The encrypt widget renders a filtered list of tiddlers to an encrypted block with the password currently held in the PasswordVault. The encrypted block can subsequently be decrypted by the TiddlyWiki5 BootMechanism. See the EncryptionMechanism for more details.

Content and Attributes

The content of the <$encrypt> widget is ignored.

TiddlyWiki on Node.js supports the following OS environment variables for specifying a colon-delimited list of paths to search for plugins and editions:

• TIDDLYWIKI_PLUGIN_PATH - Search path for ordinary plugins
• TIDDLYWIKI_THEME_PATH - Search path for themes
• TIDDLYWIKI_LANGUAGE_PATH - Search path for languages
• TIDDLYWIKI_EDITION_PATH - Search path for editions (used by the InitCommand)

The additional paths should each point to folders structured like the equivalent directories in the TiddlyWiki5 GitHub repository: the plugin, theme and language directories contain publisher/pluginname/<files> while the edition directories contain editionname/<files>

For example:

TIDDLYWIKI_PLUGIN_PATH=~/MyPluginStore
tiddlywiki mywiki --build index

This collection showcases inspiring and interesting examples of TiddlyWiki being used in the wild.

Submit new entries to this collection via GitHub, Twitter or by posting in the TiddlyWiki Groups.

External images in TiddlyWiki are tiddlers that point to the URI of an image, rather than embedding the full image data. They can perform better than embedded images, particularly with large numbers or sizes of images. However, using them breaks the single file pattern of TiddlyWiki.

External images are used in the browser. They can be created by the Node.js configuration when it builds a TiddlyWiki, or they can be created manually within the browser.

What is an External Image

An external image is an ordinary image tiddler that has a _canonical_uri field containing the URI of the image. The URI can be absoluate or relative to the HTML document. If the canonical URI is provided then the text field of the tiddler is ignored and so should be omitted.

Manually Creating External Images

To manually create an external image just create the tiddler with the appropriate image content type, and add a _canonical_uri field with a URI pointing to the actual image location.

Creating external images under Node.js

The following steps are used to create a static HTML file version of a wiki accompanied by an images folder containing the referenced external images:

1. Create image tiddlers in your TiddlyWikiFolders in the usual way
2. Save the images as separate files (by convention, in a subfolder named images)
3. Externalise the image tiddlers by giving them a _canonical_uri field
4. Save the main HTML file

Note the image files must be saved before they are externalised. Externalising them destroys the text field within the in-memory copy of the wiki store, meaning that attempts to save them will fail.

For an example see the externalimages build target of the demo tw5.com wiki:

--savetiddlers [is[image]] images
--setfield [is[image]] _canonical_uri $:/core/templates/canonical-uri-external-image text/plain
--setfield [is[image]] text "" text/plain
--rendertiddler $:/core/save/all externalimages.html text/plain

Saving Separate Image Files

The following --savetiddlers command can be used to save the images of a wiki into an images subfolder:

--savetiddlers [is[image]] images

Externalising Image Tiddlers

Two --setfield commands are used: the first sets the _canonical_uri field to a URI derived from the title of the tiddler, and the second clears the text field.

--setfield [is[image]] _canonical_uri $:/core/templates/canonical-uri-external-image text/plain
--setfield [is[image]] text "" text/plain

The template tiddler $:/core/templates/canonical-uri-external-image contains:

<!--

This template is used to assign the ''_canonical_uri'' field to external images.

Change the `./images/` part to a different base URI. The URI can be relative or absolute.

-->
./images/<$view field="title" format="doubleurlencoded"/>

Note that these operations modify the tiddlers in the wiki store and so may affect the operation of subsequent commands.

Using External Images

You can't edit an external image directly in the browser except by changing the URI field to point to a different image.

• The ability to save changes on almost any desktop HTML5 compatible-browser, with custom apps to enable Saving on iPad/iPhone and Android, and a cross-platform Firefox extension that even runs on Android
• Support for pluggable themes and colour palettes (see the control panel)
• The ability to render static HTML snapshots that can be used without JavaScript
• Bitmap images and SVG images are first-class citizens alongside text
• Concise and expressive WikiText that generates semantic HTML
• Integrated AES encryption
• TiddlyWiki isn't just a wiki - you can build custom applications with it like this TaskManagementExample
• Full internationalization support, with TiddlyWiki itself available in several languages (see the control panel)
• Familiar user interface elements like alerts, wizards and notifications
• Easily import content via drag and drop, copy and paste, or browsing for local files
• Clone existing tiddlers (for example, clone this tiddler)
• TiddlyWiki is surprisingly scalable to many thousands of tiddlers and megabytes of content
• Try out the full screen support
• Explore the D3.js visualisation plugin
• CodeMirror support via a plugin
• Markdown support via a plugin
• Many internal improvements:
  • TiddlyWiki can now be run under Node.js as well as in the browser, allowing it to be used as a personal web server
  • An elegant microkernel architecture, that allows infinite customisation by replacing and augmenting the core modules
  • TiddlyWiki version 5 can directly build both itself and previous (2.x.x) versions of TiddlyWiki from their constituent separate files, without needing external tools
  • Run the TiddlyWiki test suite from http://tiddlywiki.com/test.html
• Last but not least, TiddlyWiki is a rare example of a practical quine

The deep internal changes mean that TiddlyWiki version 5 is not compatible with previous versions, using different plugins, themes and so on. Content prepared for previous versions of TiddlyWiki will need massaging to work properly. When asking or searching for help be sure to specify TiddlyWiki5 (or TW5).

Federatial Limited is a software consultancy founded by JeremyRuston specializing in understanding the impact of the web on the way that we work together.

See http://federatial.com/ and http://twitter.com/federatial for more information.

Introduction

The field mangler widget manipulates the fields and tags of a tiddler. It does so in response to the following WidgetMessages:

Content and Attributes

The field mangler widget displays any contained content, and responds to WidgetMessages dispatched within it.

Introduction

The fields widget renders each field of a specified tiddler through a simple text template. A list of fields to exclude can be provided. It is used internally by TiddlyWiki5, notably by the FileSavingMechanism.

Template Handling

The provided template is rendered with the following special substitutions:

Content and Attributes

The content of the <$fields> widget is ignored.

The stripTitlePrefix attribute is used when building TiddlyWiki Classic; see editions/tw2 in the TiddlyWiki5 repo.

The after filter operator returns the tiddler from the current list that is after the tiddler named in the operand.

The following examples assume a tiddler called MyList with a list field containing:

one two three four five

See also FilterOperator: before, FilterOperator: previous and FilterOperator: next.

The all filter operator is used to select combinations of lists of tiddlers for subsequent operations.

The operand of the all operator is a list of names of tiddler sources joined with +.

For example:

The backlinks filter operator replaces the current list with a list of the non-system tiddlers that link to them.

For example:

The before filter operator returns the tiddler from the current list that is before the tiddler named in the operand.

The following examples assume a tiddler called MyList with a list field containing:

one two three four five

See also FilterOperator: after, FilterOperator: previous and FilterOperator: next.

The bf filter operator is a synonym for FilterOperator: rest.

The butfirst filter operator is a synonym for FilterOperator: rest.

Without an operand, the butlast filter operator returns all but the last entry in the current list. The optional operand specifies the number of entries to omit.

For example:

The commands filter operator replaces the current list with a list of the available commands (see the HelpCommand for details).

For example:

The each filter operator filters the current list to leave only the first tiddler with each distinct value for a specified field.

For example:

The each operator can be used to group tiddlers. For example, the following example creates a list of tiddlers split into types:

The eachday filter operator filters the current list to leave only the first tiddler that has a distinct value for a specified date field.

For example:

The eachday operator can be used to group tiddlers. For example, the following wiki text creates a list of the number of tiddlers that were modified on each day:

24 June 2014: 3 modifications

21 June 2014: 2 modifications

19 June 2014: 4 modifications

17 June 2014: 5 modifications

14 June 2014: 3 modifications

13 June 2014: 2 modifications

12 June 2014: 1 modifications

11 June 2014: 1 modifications

10 June 2014: 1 modifications

9 June 2014: 2 modifications

7 June 2014: 1 modifications

4 June 2014: 2 modifications

30 May 2014: 1 modifications

26 May 2014: 2 modifications

17 May 2014: 1 modifications

16 May 2014: 3 modifications

13 May 2014: 1 modifications

12 May 2014: 2 modifications

9 May 2014: 1 modifications

5 May 2014: 2 modifications

2 May 2014: 3 modifications

27 April 2014: 2 modifications

26 April 2014: 1 modifications

25 April 2014: 2 modifications

24 April 2014: 1 modifications

19 April 2014: 3 modifications

18 April 2014: 2 modifications

16 April 2014: 2 modifications

15 April 2014: 1 modifications

10 April 2014: 43 modifications

9 April 2014: 1 modifications

3 April 2014: 2 modifications

27 March 2014: 1 modifications

24 March 2014: 2 modifications

22 March 2014: 1 modifications

21 March 2014: 10 modifications

20 March 2014: 4 modifications

18 March 2014: 1 modifications

17 March 2014: 2 modifications

12 March 2014: 5 modifications

3 March 2014: 1 modifications

2 March 2014: 3 modifications

28 February 2014: 3 modifications

26 February 2014: 17 modifications

25 February 2014: 11 modifications

24 February 2014: 2 modifications

23 February 2014: 1 modifications

22 February 2014: 3 modifications

21 February 2014: 1 modifications

20 February 2014: 1 modifications

17 February 2014: 2 modifications

16 February 2014: 1 modifications

14 February 2014: 2 modifications

13 February 2014: 1 modifications

11 February 2014: 8 modifications

10 February 2014: 1 modifications

6 February 2014: 6 modifications

29 January 2014: 2 modifications

28 January 2014: 1 modifications

26 January 2014: 3 modifications

25 January 2014: 3 modifications

22 January 2014: 2 modifications

20 January 2014: 1 modifications

19 January 2014: 3 modifications

13 January 2014: 1 modifications

12 January 2014: 1 modifications

11 January 2014: 1 modifications

7 January 2014: 2 modifications

5 January 2014: 2 modifications

4 January 2014: 4 modifications

3 January 2014: 3 modifications

2 January 2014: 1 modifications

1 January 2014: 3 modifications

30 December 2013: 1 modifications

29 December 2013: 1 modifications

28 December 2013: 7 modifications

24 December 2013: 2 modifications

22 December 2013: 1 modifications

21 December 2013: 1 modifications

18 December 2013: 1 modifications

15 December 2013: 2 modifications

14 December 2013: 4 modifications

13 December 2013: 1 modifications

12 December 2013: 6 modifications

11 December 2013: 3 modifications

7 December 2013: 1 modifications

6 December 2013: 3 modifications

5 December 2013: 5 modifications

3 December 2013: 3 modifications

30 November 2013: 2 modifications

29 November 2013: 7 modifications

28 November 2013: 2 modifications

22 November 2013: 1 modifications

15 November 2013: 2 modifications

12 November 2013: 1 modifications

11 November 2013: 1 modifications

10 November 2013: 1 modifications

9 November 2013: 1 modifications

8 November 2013: 2 modifications

1 November 2013: 7 modifications

30 October 2013: 11 modifications

7 September 2013: 2 modifications

1 September 2013: 1 modifications

30 August 2013: 2 modifications

29 August 2013: 1 modifications

28 August 2013: 3 modifications

26 August 2013: 1 modifications

25 August 2013: 19 modifications

23 August 2013: 1 modifications

22 August 2013: 1 modifications

20 August 2013: 1 modifications

9 August 2013: 2 modifications

5 July 2013: 1 modifications

13 June 2013: 2 modifications

8 May 2013: 1 modifications

6 May 2013: 1 modifications

2 March 2013: 1 modifications

The field filter operator filters the current list according to whether a field matches a specified value.

The operand is the value to match, and the suffix is used to identify the field. For example:

Note that if an unknown filter operator `[unknown[xxx]]` is encountered it is interpreted as `[field:unknown[xxx]]`.

The first filter operator returns the first entries in the current list. The optional operand specifies the number of entries to return.

For example:

The get filter operator replaces the titles of the tiddlers in the current list with the values of the field specified by the operand.

For example:

The has filter operator chooses tiddlers from the current list that have a non-empty value for the field specified in the operand.

For example:

The indexes filter operator returns a list of all the property indexes found in the DataTiddlers in the current list. Tiddlers that are not DataTiddlers are ignored.

For example:

The is filter operator selects tiddlers from the current list according to their membership of the category specified in the operand:

• [is[current]] - returns any tiddler that matches the title of the current tiddler
• [is[image]] - tiddlers that contain an image (eg, GIF, JPEG, PNG etc.)
• [is[missing]] - MissingTiddlers that are referenced but undefined
• [is[orphan]] - OrphanTiddlers that are not referenced from any other tiddler
• [is[shadow]] - tiddlers that are ShadowTiddlers
• [is[system]] - tiddlers that are SystemTiddlers
• [is[tiddler]] - tiddlers that are not MissingTiddlers
• [is[tag]] - tiddlers that are being used as tags

For example:

Note that the is filter operator strictly filters the current list by choosing whether or not to include each one in the output. It never adds tiddlers to the results that are not already listed. This means that when used at the start of a run of filter operators the is operator will be choosing from the currently existing tiddlers, and so will never return missing tiddlers, or shadow tiddlers that haven't been overridden.

The last filter operator returns the last entries in the current list. The optional operand specifies the number of entries to return.

For example:

The limit filter operator trims the current list to the length specified in the operator. Usually the first tiddlers in the list are returned; preceding the operator with ! causes it to instead return the last tiddlers in the list.

For example:

The links filter operator replaces the current list with a list of the targets of outgoing links from those tiddlers.

For example:

The list filter operator replaces the current list with the list contained in the TextReference specified in the operand. The default field for the text reference is list.

Preceding the operator name with ! inverts the logic so that the filter only returns the tiddlers in the current list that are not listed in the specified list.

For example:

The listed filter operator returns the titles of the tiddlers that have list fields that contain any members of the current list. The optional operand can be used to specify a different field.

For example:

The modules filter operator treats the current list as a list of module types, and returns the titles of all of the modules of those types.

For example:

See also FilterOperator: moduletypes.

The moduletypes filter operator replaces the current list with a list of the types of the currently loaded modules.

For example:

See also FilterOperator: modules.

The next filter operator takes each tiddler in the current list and looks it up in the list field of the tiddler specified in the operand, and then returns the immediately following tiddler title.

The following examples assume a tiddler called MyList with a list field containing:

one two three four five

See also FilterOperator: previous.

The nsort filter operator sorts the current list as numeric values. String values are sorted case insensitively (upper and lower case letters are considered equivalent). Preceding the operator with ! reverses the sort order.

For example:

See also FilterOperator: sort, FilterOperator: sortcs and FilterOperator: nsortcs.

The nsortcs filter operator sorts the current list as numeric values. String values are sorted case sensitively (upper and lower case letters are considered different). Preceding the operator with ! reverses the sort order.

For example:

See also FilterOperator: sort, FilterOperator: sortcs and FilterOperator: nsort.

Without an operand, the nth filter operator returns the first entry in the current list. The optional operand specifies the number of entries to return.

For example:

The plugintiddlers filter operator returns the titles of the shadow tiddlers within any plugin tiddlers in the current list.

For example:

See also FilterOperator: shadowsource.

The prefix filter operator returns the titles in the current list that start with a specified prefix. If the prefix operator is preceded by ! then it returns the titles that do not start with the specified prefix.

For example:

See also FilterOperator: removeprefix.

The previous filter operator takes each tiddler in the current list and looks it up in the list field of the tiddler specified in the operand, and then returns the immediately preceding tiddler title.

The following examples assume a tiddler called MyList with a list field containing:

one two three four five

See also FilterOperator: next.

The removeprefix filter operator returns the titles in the current list that start with a specified prefix with the prefix removed.

For example:

See also FilterOperator: prefix.

Without an operand, the rest filter operator returns all but the first entry in the current list. The optional operand specifies the number of entries to omit.

For example:

The reverse filter operator reverses the order of the titles in the current list.

For example:

The sameday filter operator filters the current list to leave only those tiddlers whose modified field is on the same day as the date provided as the operand. The optional suffix allows a different field to be specified.

For example:

See FilterOperator: eachday for an example.

The search filter operator filters the current list to leave only those tiddlers that include the operand text in their title, body or tags. Preceding the operator with ! returns all tiddlers that do not include the specified text. The search is case-insenstive.

For example:

The shadowsource filter operator returns the titles of the plugin tiddlers containing any ShadowTiddlers in the current list.

For example:

See also FilterOperator: plugintiddlers.

The sort filter operator sorts the current list case insensitively (upper and lower case letters are considered equivalent). Preceding the operator with ! reverses the sort order.

For example:

See also FilterOperator: nsort, FilterOperator: sortcs and FilterOperator: nsortcs.

The sortcs filter operator sorts the current list case sensitively (upper and lower case letters are considered different). Preceding the operator with ! reverses the sort order.

For example:

See also FilterOperator: sort, FilterOperator: nsort and FilterOperator: nsortcs.

The tag filter operator returns the tiddlers in the current list that have the tag specified in the operand. Preceding the operator with ! returns tiddlers that do not have the specified tag.

For example:

See also FilterOperator: tagging, FilterOperator: tags and FilterOperator: untagged.

The tagging filter operator returns all the tiddlers that are tagged by the tiddlers in the current list.

For example:

See also FilterOperator: tag, FilterOperator: tags and FilterOperator: untagged.

The tags filter operator returns all the tags present on the tiddlers in the current list.

For example:

See also FilterOperator: tag, FilterOperator: tagging and FilterOperator: untagged.

The title filter operator replaces the current list with the title specified in the operand.

For example:

Note that the title operator is the default when no operator name is specified.

The untagged filter operator selects from the current list any tiddlers that do not have any tags.

For example:

See also FilterOperator: tag, FilterOperator: tagging and FilterOperator: tags.

The full list of available filter operators is:

• FilterOperator: after
• FilterOperator: all
• FilterOperator: backlinks
• FilterOperator: before
• FilterOperator: bf
• FilterOperator: butfirst
• FilterOperator: butlast
• FilterOperator: commands
• FilterOperator: each
• FilterOperator: eachday
• FilterOperator: field
• FilterOperator: first
• FilterOperator: get
• FilterOperator: has
• FilterOperator: indexes
• FilterOperator: is
• FilterOperator: last
• FilterOperator: limit
• FilterOperator: links
• FilterOperator: list
• FilterOperator: listed
• FilterOperator: modules
• FilterOperator: moduletypes
• FilterOperator: next
• FilterOperator: nsort
• FilterOperator: nsortcs
• FilterOperator: nth
• FilterOperator: plugintiddlers
• FilterOperator: prefix
• FilterOperator: previous
• FilterOperator: removeprefix
• FilterOperator: rest
• FilterOperator: reverse
• FilterOperator: sameday
• FilterOperator: search
• FilterOperator: shadowsource
• FilterOperator: sort
• FilterOperator: sortcs
• FilterOperator: tag
• FilterOperator: tagging
• FilterOperator: tags
• FilterOperator: title
• FilterOperator: untagged

Available character formatting includes:

• `backticks` for code
  • Alternatively, ``double backticks allows `embedded` backticks``
• ''bold'' for bold text
• //italic// for italic text
• __underscore__ for underscored text
• ^^superscript^^ for ^superscript text
• ,,subscript,, for _subscripted text
• ~~strikethrough~~ for strikethrough text

See also: Code Blocks in WikiText

A manifesto for the preservation of free speech through the exchange of randomized data.

Worried that using encryption will make you stand out from the crowd?

Do something about it!

Preserve our rights to free speech and association by sending Randomized Data to your friends and friends of friends – only to those who have given their consent – and encourage them to do the same.

We call data like that Freedom Bits.

TiddlyWiki is designed with the long term needs of its users in mind. Because it is OpenSource and needs no infrastructure, we can be confident that all we'll need to access a TiddlyWiki file even in the far future is an ordinary HTML browser. If you're starting to use TiddlyWiki at the beginning of your career you can be confident that it will carry you through to retirement.

TiddlyWiki5 can be used to generate static HTML representations of a TiddlyWiki that doesn't need JavaScript.

There is much flexibility in how the static HTML is generated. The following scenarios are all illustrated on http://tiddlywiki.com.

Wiki Snapshots and Tiddler Snapshots

You can explore a static representation of this TiddlyWiki at static.html. That file is a static snapshot of the current DefaultTiddlers. Any tiddlers that it links to are referred to via URLs of the form /static/HelloThere.html that point to static snapshots of individual tiddlers. The tiddler HTML files reference a static.css stylesheet file.

The included bld.sh script includes these commands that are involved in generating the sample static version of the TiddlyWiki5 site:

--rendertiddler $:/core/templates/static.template.html $TW5_BUILD_OUTPUT/static.html text/plain \
--rendertiddler $:/core/templates/static.template.css $TW5_BUILD_OUTPUT/static/static.css text/plain \
--rendertiddlers [!is[system]] $:/core/templates/static.tiddler.html $TW5_BUILD_OUTPUT/static text/plain \

The first RenderTiddlerCommand saves the static version of the DefaultTiddlers, the second saves the stylesheet, and the final RenderTiddlersCommand generates the HTML representations of individual tiddlers.

Wiki Snapshot with Internal Links

It is also possible to produce a single HTML file that contains static representations of tiddlers, and uses standard HTML anchor links to jump between them.

For example: alltiddlers.html

The example is built by the following line in bld.sh:

--rendertiddler $:/core/templates/alltiddlers.template.html $TW5_BUILD_OUTPUT/alltiddlers.html text/plain \

This is a sample task for the TaskManagementExample

This brief tutorial takes you through the basics of saving changes with a standalone TiddlyWiki5 file.

This is a sample task for the TaskManagementExample

Some suggestions for streamlining working with GoogleChrome.

Download Prompts

By default, GoogleChrome displays a confirmation prompt at the bottom of the browser window before downloading the TiddlyWiki file. Once confirmed, the file is downloaded to the default Downloads folder under a filename determined by the browser.

In Chrome settings, the advanced option "Ask where to save each file before downloading" changes this behaviour so that when you click the save button the browser displays a file picker dialogue that lets the user choose the name and location of the file, thus making it more straightforward to replace the current version of the file with the new one.

The A1 of cells

The A2 is a road from London through Kent

Take the A3 if you want to go to Basingstoke

Vitamin B1

This is cell B2, which is also transcluding A2: The A2 is a road from London through Kent.

B3 or 4

C1 eat one

Or C2 save one for later

This is cell C3, with an image

The video widget is not yet (re)implemented.

The grid widget assembles tiddlers into a tabular grid based on their titles. For example:

<$grid prefix="GridDemo" rows=3 cols=3/>

In this case, the following tiddlers will be rendered:

|GridDemo_A_1 |GridDemo_A_2 |GridDemo_A_3 |
|GridDemo_B_1 |GridDemo_B_2 |GridDemo_B_3 |
|GridDemo_C_1 |GridDemo_C_2 |GridDemo_C_3 |

The result is:

<$grid prefix="GridDemo" rows=3 cols=3/>

The usual handling of paragraphs in wikitext causes single line breaks to be ignored, and double linebreaks to be interpreted as the end of a paragraph.

This behaviour isn't convenient when dealing with material that incorporates hard linebreaks - for instance, poetry. You can mark a block of content as containing hard line breaks like this:

Headings are specified with one or more leading ! characters:

! This is a level 1 heading

!! This is a level 2 heading

!!! This is a level 3 heading

CSS classes can be assigned to individual headings like this:

!.myStyle This heading has the class `myStyle`

Welcome to TiddlyWiki, a complete interactive wiki in JavaScript. It can be used as a single HTML file in the browser or as a powerful Node.js application. It is highly customisable: the entire user interface is itself implemented in hackable WikiText.

This is version 5.0.13-beta of TiddlyWiki, a major reboot designed for the next 25 years. It is currently in beta (see the detailed ReleaseHistory). There is a RoadMap for moving to the full release. It is a great time to get involved and support the future development of TiddlyWiki.

TiddlyWiki is a free, open source project that depends on your love and support for its survival.

Displays help text for a command:

--help [<command>]

If the command name is omitted then a list of available commands is displayed.

If you find TiddlyWiki useful, there are lots of ways you can help assure its future and make it better.

Teach and Tell

OpenSource projects like TiddlyWiki thrive on the feedback and engagement of users. TiddlyWiki becomes more useful to everyone as more and more people use it. So, if you find TiddlyWiki useful, spread the word. The best possible way to assure its future is for it to become a hundred times more popular than before.

• Tweet about TiddlyWiki
• Star the TiddlyWiki5 GitHub Repository

Help improve the documentation and code

There are many ways you can contribute to TiddlyWiki:

• Writing tutorials
• Contributing to the documentation on tiddlywiki.com
• Making video screencasts
• Curating relevant links, hints and tips on a wiki

The main TiddlyWiki documentation and code lives on GitHub, and welcomes contributions:

• https://github.com/Jermolene/TiddlyWiki5

The system tiddler $:/HistoryList keeps track of a list of tiddlers comprising the navigation history. Each time you click on a link to a tiddler, the title of the target tiddler is added to the top of the stack.

The history list is stored in JSON to allow additional details about the coordinates of the DOM node that initiated the navigation.

The history list also maintains the field current-tiddler that contains the name of the tiddler at the top of the stack. This field can be used like so:

<$list filter="[list[$:/StoryList]]" history="$:/HistoryList" storyview="pop">

<$button message="tw-close-tiddler" class="btn-invisible btn-mini">&times;</$button> <$link to={{!!title}}><$view field="title"/> <$reveal type="match" state="$:/HistoryList!!current-tiddler" text=<<currentTiddler>>>&#x2713;</$reveal></$link>

</$list>

Which renders the same as the "Open" sidebar tab, with the addition of a tick against the tiddler that was last navigated to.

× HelloThere ✓

× GettingStarted

× Upgrading

× Features

× Community

× RoadMap

× Docs

You can include a horizontal rule with three or more dashes on their own on a line:

First install TiddlyWiki as described in Installing TiddlyWiki on Node.js.

1. Create an empty TiddlyWikiFolder
   1. Create a new folder in a convenient place (for example ~/MyWiki)
   2. Create a file called tiddlywiki.info containing the following text:
      • {"themes": ["tiddlywiki/vanilla","tiddlywiki/snowwhite"]}
   3. Create a subfolder called tiddlers
      • Alternatively, just copy the editions/empty folder from the TiddlyWiki5 repo
2. Create individual TiddlerFiles in the ~/MyWiki/tiddlers directory
3. Execute the following command from the TiddlyWiki5 root directory to build a TiddlyWiki5 file from the tiddlers:
   1. tiddlywiki ~/MyWiki --rendertiddler $:/core/save/all index.html text/plain